{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notebook for replicating analyses in `Rules and Rule-Making in the Five Largest Wikipedias`.\n",
    "\n",
    "Code by Sohyeon Hwang.\n",
    "\n",
    "These analyses rely on having used the .tsv files in the rule_lists folder and `get_rule_page_revisions.py` to get the tsvs of the revisions of all of the rule pages and their talk pages. We recommend storing all rule page revisions and rule talk page revisions in one subfolder.\n",
    "\n",
    "The analysis in the manuscript uses revision histories collected in July 2021. Analyses using revision histories collected more recently might differ because of changes in how rules pages are organized (e.g. if rules in the rule list become merged into one page on the wiki and thereby now share the same 'parent' page, or if a rule page has been since deleted). However, the overall trends should remain similar as the analyses are limited to dates through 2020.\n",
    "\n",
    "Some sections of this notebook get long as we cross-check data as we go."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can install any packages in the notebook with the following line, e.g. as we do for venn here\n",
    "# !{sys.executable} -m pip install venn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Various import statements. You may need to install some packages.\n",
    "import argparse, os\n",
    "import re, random, urllib, simplejson, json, copy, itertools\n",
    "import urllib.parse, urllib.request, urllib.error\n",
    "from datetime import datetime\n",
    "import requests, time\n",
    "from pathlib import Path\n",
    "\n",
    "from operator import itemgetter\n",
    "from collections import Counter\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "import wikifunctions as wf\n",
    "\n",
    "from multiprocessing import Pool, Manager, Process, cpu_count\n",
    "from functools import partial\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.lines import Line2D\n",
    "import seaborn as sb\n",
    "sb.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load up data\n",
    "\n",
    "... and do a lot of dataframe wrangling. Some of the processing below can be done much more efficiently (in fewer lines), but Sohyeon did them one by one to check the data manually before doing analyses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "langs = [\"de\",\"en\",\"es\",\"fr\",\"ja\"]\n",
    "\n",
    "# list of rules\n",
    "rules_df_de = pd.read_csv(Path(os.getcwd()) / \"rule_lists\" / \"dewiki.tsv\",sep=\"\\t\",header=None)\n",
    "rules_df_en = pd.read_csv(Path(os.getcwd()) / \"rule_lists\" / \"enwiki.tsv\",sep=\"\\t\",header=None)\n",
    "rules_df_es = pd.read_csv(Path(os.getcwd()) / \"rule_lists\" / \"eswiki.tsv\",sep=\"\\t\",header=None)\n",
    "rules_df_fr = pd.read_csv(Path(os.getcwd()) / \"rule_lists\" / \"frwiki.tsv\",sep=\"\\t\",header=None)\n",
    "rules_df_ja = pd.read_csv(Path(os.getcwd()) / \"rule_lists\" / \"jawiki.tsv\",sep=\"\\t\",header=None)\n",
    "rules_dfs = [rules_df_de,rules_df_en,rules_df_es,rules_df_fr,rules_df_ja]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note below, that rev_path should be adapted to reflect the directory where you have saved the revisions for the rules for each language edition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the revision history path\n",
    "rev_path = Path(os.getcwd()) / \"output_rulepagerevs\" / \"2022-06-06\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_10268\\28759238.py:3: DtypeWarning: Columns (0,3,14) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  rev_df_en = pd.read_csv( rev_path / \"en_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_10268\\28759238.py:5: DtypeWarning: Columns (14,15,16,17) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  rev_df_fr = pd.read_csv( rev_path / \"fr_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n"
     ]
    }
   ],
   "source": [
    "# page revision histories\n",
    "rev_df_de = pd.read_csv( rev_path / \"de_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
    "rev_df_en = pd.read_csv( rev_path / \"en_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
    "rev_df_es = pd.read_csv( rev_path / \"es_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
    "rev_df_fr = pd.read_csv( rev_path / \"fr_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
    "rev_df_ja = pd.read_csv( rev_path / \"ja_revisions.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'])\n",
    "\n",
    "# talk page revision histories\n",
    "talkrev_df_de = pd.read_csv( rev_path / \"de_revisions_talk.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'],low_memory=False)\n",
    "talkrev_df_en = pd.read_csv( rev_path / \"en_revisions_talk.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'],low_memory=False)\n",
    "talkrev_df_es = pd.read_csv( rev_path / \"es_revisions_talk.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'],low_memory=False)\n",
    "talkrev_df_fr = pd.read_csv( rev_path / \"fr_revisions_talk.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'],low_memory=False)\n",
    "talkrev_df_ja = pd.read_csv( rev_path / \"ja_revisions_talk.tsv\",sep='\\t',header=0,encoding='utf8',parse_dates=['date','timestamp'],low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get rid of duplicate revisions for each language edition\n",
    "rev_df_de.drop_duplicates(subset=['revid'],inplace=True)\n",
    "rev_df_en.drop_duplicates(subset=['revid'],inplace=True)\n",
    "rev_df_es.drop_duplicates(subset=['revid'],inplace=True)\n",
    "rev_df_fr.drop_duplicates(subset=['revid'],inplace=True)\n",
    "rev_df_ja.drop_duplicates(subset=['revid'],inplace=True)\n",
    "\n",
    "talkrev_df_de.drop_duplicates(subset=['revid'],inplace=True)\n",
    "talkrev_df_en.drop_duplicates(subset=['revid'],inplace=True)\n",
    "talkrev_df_es.drop_duplicates(subset=['revid'],inplace=True)\n",
    "talkrev_df_fr.drop_duplicates(subset=['revid'],inplace=True)\n",
    "talkrev_df_ja.drop_duplicates(subset=['revid'],inplace=True)\n",
    "\n",
    "# get rid of incomplete data\n",
    "rev_df_de.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "rev_df_en.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "rev_df_es.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "rev_df_fr.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "rev_df_ja.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "\n",
    "talkrev_df_de.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "talkrev_df_en.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "talkrev_df_es.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "talkrev_df_fr.dropna(subset=['revid','date','diff','lag'],inplace=True)\n",
    "talkrev_df_ja.dropna(subset=['revid','date','diff','lag'],inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a column for the year of the revision\n",
    "rev_df_de['year'] = rev_df_de['timestamp'].dt.strftime('%Y')\n",
    "rev_df_de['year'] = rev_df_de['year'].astype(np.int64)\n",
    "talkrev_df_de['year'] = talkrev_df_de['timestamp'].dt.strftime('%Y')\n",
    "talkrev_df_de['year'] = talkrev_df_de['year'].astype(np.int64)\n",
    "\n",
    "rev_df_en['year'] = rev_df_en['date'].dt.strftime('%Y')\n",
    "rev_df_en['year'] = rev_df_en['year'].astype(np.int64)\n",
    "talkrev_df_en['year'] = talkrev_df_en['timestamp'].dt.strftime('%Y')\n",
    "talkrev_df_en['year'] = talkrev_df_en['year'].astype(np.int64)\n",
    "\n",
    "rev_df_es['year'] = rev_df_es['timestamp'].dt.strftime('%Y')\n",
    "rev_df_es['year'] = rev_df_es['year'].astype(np.int64)\n",
    "talkrev_df_es['year'] = talkrev_df_es['timestamp'].dt.strftime('%Y')\n",
    "talkrev_df_es['year'] = talkrev_df_es['year'].astype(np.int64)\n",
    "\n",
    "rev_df_fr['year'] = rev_df_fr['timestamp'].dt.strftime('%Y')\n",
    "rev_df_fr['year'] = rev_df_fr['year'].astype(np.int64)\n",
    "talkrev_df_fr['year'] = talkrev_df_fr['timestamp'].dt.strftime('%Y')\n",
    "talkrev_df_fr['year'] = talkrev_df_fr['year'].astype(np.int64)\n",
    "\n",
    "rev_df_ja['year'] = rev_df_ja['timestamp'].dt.strftime('%Y')\n",
    "rev_df_ja['year'] = rev_df_ja['year'].astype(np.int64)\n",
    "talkrev_df_ja['year'] = talkrev_df_ja['timestamp'].dt.strftime('%Y')\n",
    "talkrev_df_ja['year'] = talkrev_df_ja['year'].astype(np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "rev_df_de['year_since_first'] = rev_df_de.year.astype(np.int64) - rev_df_de.year.astype(np.int64).min()\n",
    "rev_df_en['year_since_first'] = rev_df_en.year.astype(np.int64) - rev_df_en.year.astype(np.int64).min()\n",
    "rev_df_es['year_since_first'] = rev_df_es.year.astype(np.int64) - rev_df_es.year.astype(np.int64).min()\n",
    "rev_df_fr['year_since_first'] = rev_df_fr.year.astype(np.int64) - rev_df_fr.year.astype(np.int64).min()\n",
    "rev_df_ja['year_since_first'] = rev_df_ja.year.astype(np.int64) - rev_df_ja.year.astype(np.int64).min()\n",
    "\n",
    "talkrev_df_de['year_since_first'] = talkrev_df_de.year.astype(np.int64) - rev_df_de.year.astype(np.int64).min()\n",
    "talkrev_df_en['year_since_first'] = talkrev_df_en.year.astype(np.int64) - rev_df_en.year.astype(np.int64).min()\n",
    "talkrev_df_es['year_since_first'] = talkrev_df_es.year.astype(np.int64) - rev_df_es.year.astype(np.int64).min()\n",
    "talkrev_df_fr['year_since_first'] = talkrev_df_fr.year.astype(np.int64) - rev_df_fr.year.astype(np.int64).min()\n",
    "talkrev_df_ja['year_since_first'] = talkrev_df_ja.year.astype(np.int64) - rev_df_ja.year.astype(np.int64).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "rev_df_de = rev_df_de[rev_df_de.year <= 2020]\n",
    "rev_df_en = rev_df_en[rev_df_en.year <= 2020]\n",
    "rev_df_es = rev_df_es[rev_df_es.year <= 2020]\n",
    "rev_df_fr = rev_df_fr[rev_df_fr.year <= 2020]\n",
    "rev_df_ja = rev_df_ja[rev_df_ja.year <= 2020]\n",
    "\n",
    "talkrev_df_de = talkrev_df_de[talkrev_df_de.year <= 2020]\n",
    "talkrev_df_en = talkrev_df_en[talkrev_df_en.year <= 2020]\n",
    "talkrev_df_es = talkrev_df_es[talkrev_df_es.year <= 2020]\n",
    "talkrev_df_fr = talkrev_df_fr[talkrev_df_fr.year <= 2020]\n",
    "talkrev_df_ja = talkrev_df_ja[talkrev_df_ja.year <= 2020]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create 'parent' pages to match rule and their talk pages\n",
    "rev_df_en['parent_page_title'] = rev_df_en.copy()['page']\n",
    "rev_df_de['parent_page_title'] = rev_df_de.copy()['page']\n",
    "rev_df_es['parent_page_title'] = rev_df_es.copy()['page']\n",
    "rev_df_fr['parent_page_title'] = rev_df_fr.copy()['page']\n",
    "rev_df_ja['parent_page_title'] = rev_df_ja.copy()['page']\n",
    "\n",
    "talkrev_df_en['parent_page_title'] = talkrev_df_en['page'].apply(lambda x:x[:9]+x[14:] if x[:9]=='Wikipedia' else x[:8]+x[13:])\n",
    "talkrev_df_de['parent_page_title'] = talkrev_df_de['page'].apply(lambda x:x[:9]+x[20:] if x[:9]=='Wikipedia' else x[:6]+x[17:])\n",
    "talkrev_df_es['parent_page_title'] = talkrev_df_es['page'].apply(lambda x:x[:9]+x[19:])\n",
    "talkrev_df_fr['parent_page_title'] = talkrev_df_fr['page'].apply(lambda x:x[11:])\n",
    "talkrev_df_ja['parent_page_title'] = talkrev_df_ja['page'].apply(lambda x:x[:9]+x[13:] if x[:9]=='Wikipedia' else x[:6]+x[10:])\n",
    "\n",
    "def usuaria(row):\n",
    "    if \"Usuaria discusión:\" in row['page']:\n",
    "        if \"Usuaria discusión:\" == row['page'][:18]:\n",
    "            print(row['page'], '\\t', row['parent_page_title'])\n",
    "            fixed = \"Usuaria:{}\".format(row['page'][18:])\n",
    "            print(fixed)\n",
    "            return fixed\n",
    "    else:\n",
    "        return row['parent_page_title']\n",
    "\n",
    "talkrev_df_es['parent_page_title'] = talkrev_df_es.apply(usuaria,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# finding the first revision date for each rule\n",
    "min_rulerev_date = rev_df_de.groupby(['page']).agg({'date':np.min})['date']\n",
    "min_rulerev_date_dict_de = min_rulerev_date.to_dict()\n",
    "\n",
    "min_rulerev_date = rev_df_en.groupby(['page']).agg({'date':np.min})['date']\n",
    "min_rulerev_date_dict_en = min_rulerev_date.to_dict()\n",
    "\n",
    "min_rulerev_date = rev_df_es.groupby(['page']).agg({'date':np.min})['date']\n",
    "min_rulerev_date_dict_es = min_rulerev_date.to_dict()\n",
    "\n",
    "min_rulerev_date = rev_df_fr.groupby(['page']).agg({'date':np.min})['date']\n",
    "min_rulerev_date_dict_fr = min_rulerev_date.to_dict()\n",
    "\n",
    "min_rulerev_date = rev_df_ja.groupby(['page']).agg({'date':np.min})['date']\n",
    "min_rulerev_date_dict_ja = min_rulerev_date.to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now we can identify the year the rule was created\n",
    "rev_df_de['creation_year'] = rev_df_de['page'].map({k:v.year for k,v in min_rulerev_date_dict_de.items()})\n",
    "rev_df_en['creation_year'] = rev_df_en['page'].map({k:v.year for k,v in min_rulerev_date_dict_en.items()})\n",
    "rev_df_es['creation_year'] = rev_df_es['page'].map({k:v.year for k,v in min_rulerev_date_dict_es.items()})\n",
    "rev_df_fr['creation_year'] = rev_df_fr['page'].map({k:v.year for k,v in min_rulerev_date_dict_fr.items()})\n",
    "rev_df_ja['creation_year'] = rev_df_ja['page'].map({k:v.year for k,v in min_rulerev_date_dict_ja.items()})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for talk pages, use their parent title to do the same\n",
    "talkrev_df_de['creation_year'] = talkrev_df_de['parent_page_title'].map({k:v.year for k,v in min_rulerev_date_dict_de.items()})\n",
    "talkrev_df_en['creation_year'] = talkrev_df_en['parent_page_title'].map({k:v.year for k,v in min_rulerev_date_dict_en.items()})\n",
    "talkrev_df_es['creation_year'] = talkrev_df_es['parent_page_title'].map({k:v.year for k,v in min_rulerev_date_dict_es.items()})\n",
    "talkrev_df_fr['creation_year'] = talkrev_df_fr['parent_page_title'].map({k:v.year for k,v in min_rulerev_date_dict_fr.items()})\n",
    "talkrev_df_ja['creation_year'] = talkrev_df_ja['parent_page_title'].map({k:v.year for k,v in min_rulerev_date_dict_ja.items()})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rev_df_en timestamp needs to be made into a datetime object\n",
    "rev_df_en['timestamp'] = pd.to_datetime(rev_df_en['timestamp'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine all_revs per language edition (page + talk) again, with the new stuff\n",
    "allrevs_de = pd.concat([rev_df_de,talkrev_df_de]).sort_values('timestamp')\n",
    "allrevs_en = pd.concat([rev_df_en,talkrev_df_en]).sort_values('timestamp')\n",
    "allrevs_es = pd.concat([rev_df_es,talkrev_df_es]).sort_values('timestamp')\n",
    "allrevs_fr = pd.concat([rev_df_fr,talkrev_df_fr]).sort_values('timestamp')\n",
    "allrevs_ja = pd.concat([rev_df_ja,talkrev_df_ja]).sort_values('timestamp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "rev_df_list = [rev_df_en,rev_df_fr,rev_df_de,rev_df_ja,rev_df_es]\n",
    "talkrev_df_list = [talkrev_df_en,talkrev_df_fr,talkrev_df_de,talkrev_df_ja,talkrev_df_es]\n",
    "allrev_df_list = [allrevs_en,allrevs_fr,allrevs_de,allrevs_ja,allrevs_es]\n",
    "\n",
    "rev_df_names = ['English','French','German','Japanese','Spanish']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Descriptives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Through 2020...\n",
      "In German Wikipedia, there are 122 rule pages and 115 corresponding talk pages; 13587 unique users contributed to these\n",
      "In English Wikipedia, there are 313 rule pages and 308 corresponding talk pages; 80813 unique users contributed to these\n",
      "In Spanish Wikipedia, there are 105 rule pages and 88 corresponding talk pages; 7050 unique users contributed to these\n",
      "In French Wikipedia, there are 127 rule pages and 120 corresponding talk pages; 6411 unique users contributed to these\n",
      "In Japanese Wikipedia, there are 113 rule pages and 112 corresponding talk pages; 5517 unique users contributed to these\n",
      "German:\t\t 2001-06-19 06:38:40+00:00\t2020-12-31 23:31:51+00:00\n",
      "English:\t 2001-01-21 09:36:15+00:00\t2020-12-31 23:42:31+00:00\n",
      "Spanish:\t 2002-01-11 19:58:15+00:00\t2020-12-31 11:50:10+00:00\n",
      "French:\t\t 2001-11-26 20:48:06+00:00\t2020-12-31 20:47:43+00:00\n",
      "Japanese:\t 2003-02-02 09:10:23+00:00\t2020-12-31 00:19:50+00:00\n"
     ]
    }
   ],
   "source": [
    "print('Through 2020...')\n",
    "print('In {} Wikipedia, there are {} rule pages and {} corresponding talk pages; {} unique users contributed to these'.format('German', len(set(rev_df_de['page'])), len(set(talkrev_df_de['page'])), len(allrevs_de['user'].unique()) ))\n",
    "print('In {} Wikipedia, there are {} rule pages and {} corresponding talk pages; {} unique users contributed to these'.format('English', len(set(rev_df_en['page'])), len(set(talkrev_df_en['page'])), len(allrevs_en['user'].unique()) ))\n",
    "print('In {} Wikipedia, there are {} rule pages and {} corresponding talk pages; {} unique users contributed to these'.format('Spanish', len(set(rev_df_es['page'])), len(set(talkrev_df_es['page'])), len(allrevs_es['user'].unique()) ))\n",
    "print('In {} Wikipedia, there are {} rule pages and {} corresponding talk pages; {} unique users contributed to these'.format('French', len(set(rev_df_fr['page'])), len(set(talkrev_df_fr['page'])), len(allrevs_fr['user'].unique()) ))\n",
    "print('In {} Wikipedia, there are {} rule pages and {} corresponding talk pages; {} unique users contributed to these'.format('Japanese', len(set(rev_df_ja['page'])), len(set(talkrev_df_ja['page'])), len(allrevs_ja['user'].unique()) ))\n",
    "\n",
    "print( 'German:\\t\\t {}\\t{}'.format( allrevs_de['timestamp'].min(), allrevs_de['timestamp'].max() ))\n",
    "print( 'English:\\t {}\\t{}'.format( allrevs_en['timestamp'].min(), allrevs_en['timestamp'].max() ))\n",
    "print( 'Spanish:\\t {}\\t{}'.format( allrevs_es['timestamp'].min(), allrevs_es['timestamp'].max() ))\n",
    "print( 'French:\\t\\t {}\\t{}'.format( allrevs_fr['timestamp'].min(), allrevs_fr['timestamp'].max() ))\n",
    "print( 'Japanese:\\t {}\\t{}'.format( allrevs_ja['timestamp'].min(), allrevs_ja['timestamp'].max() ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RQ1 Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb.set(rc={'figure.figsize':(11.7,8.27)})\n",
    "sb.set_style(\"whitegrid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "linestyles = ['-','--','-','--','-','--','-','--']\n",
    "year_order = range(2001,2021)\n",
    "_hue_order = ['English','French','German','Japanese','Spanish']\n",
    "\n",
    "creation_by_year_df = pd.DataFrame(index=range(2001,2021))\n",
    "\n",
    "creation_by_year_df['German'] = pd.Series(Counter([pd.to_datetime(i).year for i in min_rulerev_date_dict_de.values()]))\n",
    "creation_by_year_df['English'] = pd.Series(Counter([pd.to_datetime(i).year for i in min_rulerev_date_dict_en.values()]))\n",
    "creation_by_year_df['Spanish'] = pd.Series(Counter([pd.to_datetime(i).year for i in min_rulerev_date_dict_es.values()]))\n",
    "creation_by_year_df['French'] = pd.Series(Counter([pd.to_datetime(i).year for i in min_rulerev_date_dict_fr.values()]))\n",
    "creation_by_year_df['Japanese'] = pd.Series(Counter([pd.to_datetime(i).year for i in min_rulerev_date_dict_ja.values()]))\n",
    "\n",
    "creation_by_year_df_years_since = creation_by_year_df.reset_index()\n",
    "creation_by_year_df_years_since['Japanese'] = creation_by_year_df_years_since['Japanese'].shift(-2)\n",
    "creation_by_year_df_years_since['Spanish'] = creation_by_year_df_years_since['Spanish'].shift(-1)\n",
    "#creation_by_year_df_years_since['years_since'] = range(1,21)\n",
    "creation_by_year_df_years_since = creation_by_year_df_years_since.drop(columns = \"index\")\n",
    "creation_by_year_df_years_since = creation_by_year_df_years_since.fillna(0).div(creation_by_year_df_years_since.sum()).reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\sohye\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 540x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Figure 2(a) - Cumulative distribution function of proportion of rules created\n",
    "_melted = pd.melt(creation_by_year_df_years_since,id_vars=['index'],value_vars=_hue_order)\n",
    "_melted['cumsum'] = _melted.groupby('variable')['value'].cumsum()\n",
    "g = sb.factorplot(x='index',y='cumsum',hue='variable',data=_melted,legend=False,kind='point',\n",
    "                   hue_order=_hue_order,palette='colorblind',order=range(0,20),aspect=1.5)\n",
    "g.set_yticklabels(fontsize=30)\n",
    "g.axes[0][0].set_xlabel('')\n",
    "g.axes[0][0].set_ylabel('')\n",
    "g.axes[0][0].set_ylim((0,1.1))\n",
    "g.axes[0][0].set_xlim((-.25,17.18))\n",
    "\n",
    "cb_palette = sb.color_palette('colorblind',n_colors=5)\n",
    "\n",
    "legend_elements = [Line2D([0], [0], color=cb_palette[0], lw=10),\n",
    "                   Line2D([0], [0], color=cb_palette[1], lw=10),\n",
    "                   Line2D([0], [0], color=cb_palette[2], lw=10),\n",
    "                   Line2D([0], [0], color=cb_palette[3], lw=10),\n",
    "                   Line2D([0], [0], color=cb_palette[4], lw=10)]\n",
    "#plt.legend(legend_elements,_hue_order,bbox_to_anchor=(1,1),loc='upper left',fontsize=30)\n",
    "\n",
    "plt.legend(legend_elements,_hue_order,loc='center',fontsize=28,bbox_to_anchor=(0.8,0.35))\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\sohye\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 750x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Figure 2(b) - Median number of rule-related revisions over the years\n",
    "_dfs = []\n",
    "for i,(rev_df,name) in enumerate(zip(allrev_df_list,rev_df_names)): #TODO\n",
    "    #print(name)\n",
    "    _df = rev_df.groupby(['creation_year','parent_page_title','year_since_first']).agg({'revid':'count'}).rename(columns={\"revid\":\"rev_count\"})['rev_count']\n",
    "    _df = _df.reset_index()\n",
    "    _df['lang'] = name\n",
    "    _dfs.append(_df)\n",
    "\n",
    "allrevs_year_df = pd.concat(_dfs)\n",
    "allrevs_year_df = allrevs_year_df.drop(columns='parent_page_title')\n",
    "\n",
    "# median count of all rule-related revisions (median by rule)\n",
    "g = sb.factorplot(x='year_since_first',y='rev_count',hue='lang',data=allrevs_year_df.groupby(['lang','year_since_first']).agg({\"rev_count\":\"median\"}).reset_index(),\n",
    "                  legend=False,kind='point',hue_order=_hue_order,palette='colorblind',order=range(0,20),aspect=1.5)\n",
    "g.set_yticklabels(fontsize=30)\n",
    "g.axes[0][0].set_ylabel('') #Median number of revisions to rules\n",
    "g.axes[0][0].set_xlabel('')\n",
    "g.axes[0][0].set_ylim((0,140))\n",
    "g.axes[0][0].set_xlim((-.25,17.18))\n",
    "\n",
    "#plt.legend(loc='center',bbox_to_anchor=(0.5,-0.3),ncol=5)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "## a little wrangling for figure 2(c)\n",
    "activity_by_year_df_de = pd.DataFrame()\n",
    "activity_by_year_df_de['Rule activity'] = rev_df_de.groupby(['year_since_first']).agg({'revid':len})['revid'] #year\n",
    "activity_by_year_df_de['Rule talk activity'] = talkrev_df_de.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "\n",
    "activity_by_year_df_en = pd.DataFrame()\n",
    "activity_by_year_df_en['Rule activity'] = rev_df_en.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "activity_by_year_df_en['Rule talk activity'] = talkrev_df_en.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "\n",
    "activity_by_year_df_es = pd.DataFrame()\n",
    "activity_by_year_df_es['Rule activity'] = rev_df_es.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "activity_by_year_df_es['Rule talk activity'] = talkrev_df_es.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "\n",
    "activity_by_year_df_fr = pd.DataFrame()\n",
    "activity_by_year_df_fr['Rule activity'] = rev_df_fr.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "activity_by_year_df_fr['Rule talk activity'] = talkrev_df_fr.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "\n",
    "activity_by_year_df_ja = pd.DataFrame()\n",
    "activity_by_year_df_ja['Rule activity'] = rev_df_ja.groupby(['year_since_first']).agg({'revid':len})['revid']\n",
    "activity_by_year_df_ja['Rule talk activity'] = talkrev_df_ja.groupby(['year_since_first']).agg({'revid':len})['revid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\sohye\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 750x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Figure 2(c) - percent revisions on rule to talk\n",
    "\n",
    "# rule page revisions : rule talk page revisions (% of rule-related revisions being on actual rule page), smoother\n",
    "_activitybyyears = [activity_by_year_df_en,activity_by_year_df_fr,activity_by_year_df_de,activity_by_year_df_ja,activity_by_year_df_es]\n",
    "_names = ['en','fr','de','ja','es']\n",
    "rev_df_names = ['English','French','German','Japanese','Spanish']\n",
    "\n",
    "first = True \n",
    "\n",
    "for i,langdf in enumerate(_activitybyyears):\n",
    "    percentage = langdf[\"Rule activity\"] / (langdf[\"Rule activity\"] + langdf[\"Rule talk activity\"])\n",
    "    percentage_df = pd.DataFrame(percentage, columns=[rev_df_names[i]]).fillna(1.0)\n",
    "    #print(percentage_df)\n",
    "\n",
    "    if not first:\n",
    "        new_df = new_df.merge(percentage_df,how='outer',on=['year_since_first'])\n",
    "    else:\n",
    "        new_df = percentage_df\n",
    "        first = False\n",
    "        #print('teehee',_names[i])\n",
    "\n",
    "new_df.reset_index(inplace=True)\n",
    "_melted = new_df.melt(id_vars=['year_since_first'],value_vars=rev_df_names)\n",
    "\n",
    "sb.set_style('whitegrid')\n",
    "g = sb.factorplot(x='year_since_first',y='value',hue='variable',data=_melted,legend=False,kind='point',\n",
    "                   hue_order=_hue_order,palette='colorblind',order=range(0,20),aspect=1.5)\n",
    "g.set_yticklabels(fontsize=30)\n",
    "g.axes[0][0].set_ylim((0,1.01))\n",
    "g.axes[0][0].set_xlim((-0.25,17.18))\n",
    "g.axes[0][0].set_ylabel('') #% Revisions on Rule (vs talk) page\n",
    "g.axes[0][0].set_xlabel('')\n",
    "#plt.legend(loc='center',bbox_to_anchor=(0.5,-.15),ncol=5)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## figure 3\n",
    "custom_cmap = [(0.20973515, 0.09747934, 0.24238489),(0.20973515, 0.09747934, 0.24238489),(0.20973515, 0.09747934, 0.24238489),(0.43860848, 0.12177004, 0.34119475),(0.43860848, 0.12177004, 0.34119475),(0.43860848, 0.12177004, 0.34119475),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148),(0.67824099, 0.09192342, 0.3504148)]\n",
    "\n",
    "def get_total_revs_that_year(row):\n",
    "    y = row.year_since_first\n",
    "    #print(total_revs_in_year)\n",
    "    return total_revs_in_year['revid'][y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 English\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:7: FutureWarning: Using the level keyword in DataFrame and Series aggregations is deprecated and will be removed in a future version. Use groupby instead. df.median(level=1) should use df.groupby(level=1).median().\n",
      "  _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 French\n",
      "2 German\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:7: FutureWarning: Using the level keyword in DataFrame and Series aggregations is deprecated and will be removed in a future version. Use groupby instead. df.median(level=1) should use df.groupby(level=1).median().\n",
      "  _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:52: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:7: FutureWarning: Using the level keyword in DataFrame and Series aggregations is deprecated and will be removed in a future version. Use groupby instead. df.median(level=1) should use df.groupby(level=1).median().\n",
      "  _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:52: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 Japanese\n",
      "4 Spanish\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:7: FutureWarning: Using the level keyword in DataFrame and Series aggregations is deprecated and will be removed in a future version. Use groupby instead. df.median(level=1) should use df.groupby(level=1).median().\n",
      "  _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:52: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:7: FutureWarning: Using the level keyword in DataFrame and Series aggregations is deprecated and will be removed in a future version. Use groupby instead. df.median(level=1) should use df.groupby(level=1).median().\n",
      "  _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1208984352.py:52: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# figure 3 - early, growth, decline\n",
    "f,axs = plt.subplots(1,5,figsize=(24,4))\n",
    "\n",
    "for i,(rev_df,name) in enumerate(zip(allrev_df_list,rev_df_names)):\n",
    "    print(i,name)\n",
    "    _df = rev_df.groupby(['creation_year','page','year_since_first']).agg({'revid':len})['revid']\n",
    "    _df = _df.mean(level=['creation_year','year_since_first']).unstack('creation_year')#.fillna(method='ffill') # .cumsum() before fillna\n",
    "    _df = _df.reindex(columns=range(0,20))\n",
    "\n",
    "    _df = rev_df.groupby(['creation_year','parent_page_title','year_since_first']).agg({'revid':\"count\"})['revid']\n",
    "    _df = _df.reset_index()\n",
    "    _df['lang'] = name\n",
    "    total_revs_in_year = _df.groupby(['year_since_first']).agg({'revid':sum}).to_dict()\n",
    "    _df['total_revs_yearly'] = _df.apply(get_total_revs_that_year,axis=1)\n",
    "\n",
    "    _df[\"percentage_revs\"] = _df.revid.astype(np.float32) / _df.total_revs_yearly.astype(np.float32)\n",
    "    _df = _df.groupby([\"lang\",\"year_since_first\",\"creation_year\"]).agg({\"percentage_revs\":\"sum\"}).reset_index()\n",
    "    _df = _df.pivot(index=\"year_since_first\",columns=\"creation_year\",values=\"percentage_revs\")\n",
    "\n",
    "    #print(_df)\n",
    "\n",
    "    _df.plot(kind='area',stacked=True,legend=False,alpha=0.95,ax=axs[i],color=custom_cmap)\n",
    "\n",
    "    axs[i].set_xticks(range(0,20))\n",
    "    axs[i].set_xticklabels(range(0,20))\n",
    "    axs[i].set_title(name,fontsize=13)\n",
    "    axs[i].set_xlabel('')\n",
    "\n",
    "    if name == \"Japanese\":\n",
    "        axs[i].set_xticks(range(0,20))\n",
    "        axs[i].set_xlim(0,17)\n",
    "    elif name == \"Spanish\":\n",
    "        axs[i].set_xticks(range(0,20))\n",
    "        axs[i].set_xlim(0,17)\n",
    "    else:\n",
    "        axs[i].set_xticks(range(0,20))\n",
    "        axs[i].set_xlim(0,17)\n",
    "    axs[i].set_xticklabels(range(0,20))\n",
    "    axs[i].set_title(name,fontsize=13)\n",
    "    axs[i].set_xlabel('')\n",
    "    axs[i].set_ylim(0,1)\n",
    "\n",
    "    if i == 0:\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "        axs[i].set_yticks([0.0,0.2,0.4,0.6,0.8,1.0])\n",
    "        axs[i].set_yticklabels([0.0,0.2,0.4,0.6,0.8,1.0],fontsize=30)\n",
    "\n",
    "    else:\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "        axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
    "\n",
    "#axs[0].set_ylabel('Percent of revisions to a rule created in X era')\n",
    "from matplotlib.lines import Line2D\n",
    "legend_elements = [Line2D([0], [0], color=(0.67824099, 0.09192342, 0.3504148), lw=10),\n",
    "                   Line2D([0], [0], color=(0.43860848, 0.12177004, 0.34119475), lw=10),\n",
    "                   Line2D([0], [0], color=(0.20973515, 0.09747934, 0.24238489), lw=10)]\n",
    "#f.legend(legend_elements,['early','growth','decline'],bbox_to_anchor=(1,1),loc='upper left',ncol=3)\n",
    "plt.legend(legend_elements,['decline','growth','early'],bbox_to_anchor=(1,1),loc='upper left',fontsize=30)\n",
    "f.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "## for Figure 4\n",
    "\n",
    "revision_list = rev_df_list #you can also do this with allrev_df_list, which includes ALL rule-related revisions\n",
    "\n",
    "for rev_df in revision_list:\n",
    "    rev_df['month'] = rev_df['date'].dt.strftime('%m')\n",
    "    rev_df['month'] = pd.to_numeric(rev_df['month'])\n",
    "\n",
    "_index = pd.date_range(start='1/1/2001', end='12/31/2020',freq='M')\n",
    "_columns = ['Y','M']\n",
    "\n",
    "# all\n",
    "monthlyall_df = pd.DataFrame(index=_index, columns=_columns)\n",
    "monthlyall_df = monthlyall_df.reset_index().rename(columns={\"index\":\"datestamp\"})\n",
    "monthlyall_df['M'] = pd.to_numeric(monthlyall_df.datestamp.dt.strftime('%m'))\n",
    "monthlyall_df['Y'] = pd.to_numeric(monthlyall_df.datestamp.dt.strftime('%Y'))\n",
    "monthlyall_df = monthlyall_df.drop(columns=[\"datestamp\"])\n",
    "\n",
    "# diff\n",
    "for i,(rev_df,name) in enumerate(zip(revision_list,rev_df_names)):\n",
    "    _df = rev_df.groupby(['year','month','parent_page_title']).agg({'diff':np.mean}) #mean\n",
    "    _df = _df.groupby(['year','month']).agg({'diff':np.median})\n",
    "    monthlyall_df[name] = monthlyall_df.merge(_df,how=\"left\",left_on=[\"Y\",\"M\"],right_on=[\"year\",\"month\"])[\"diff\"]\n",
    "\n",
    "monthlyall_df_diff_long = monthlyall_df.melt(id_vars=['Y','M']).rename(columns={\"variable\":\"lang\",\"value\":\"median_avgdiff\"})\n",
    "\n",
    "# lag\n",
    "monthlyall_df = pd.DataFrame(index=_index, columns=_columns)\n",
    "monthlyall_df = monthlyall_df.reset_index().rename(columns={\"index\":\"datestamp\"})\n",
    "monthlyall_df['M'] = pd.to_numeric(monthlyall_df.datestamp.dt.strftime('%m'))\n",
    "monthlyall_df['Y'] = pd.to_numeric(monthlyall_df.datestamp.dt.strftime('%Y'))\n",
    "monthlyall_df = monthlyall_df.drop(columns=[\"datestamp\"])\n",
    "\n",
    "for i,(rev_df,name) in enumerate(zip(revision_list,rev_df_names)):\n",
    "    _df = rev_df.groupby(['year','month','parent_page_title']).agg({'lag':np.mean}) #mean\n",
    "    _df = _df.groupby(['year','month']).agg({'lag':np.median})\n",
    "    monthlyall_df[name] = monthlyall_df.merge(_df,how=\"left\",left_on=[\"Y\",\"M\"],right_on=[\"year\",\"month\"])[\"lag\"]\n",
    "\n",
    "monthlyall_df_lag_long = monthlyall_df.melt(id_vars=['Y','M']).rename(columns={\"variable\":\"lang\",\"value\":\"median_avglag\"})\n",
    "\n",
    "monthlyall_df_diff_long = monthlyall_df_diff_long.groupby(['lang','Y']).agg({'median_avgdiff':np.median}).reset_index()\n",
    "monthlyall_df_lag_long = monthlyall_df_lag_long.groupby(['lang','Y']).agg({'median_avglag':np.median}).reset_index()\n",
    "monthlyall_df_long = monthlyall_df_lag_long.merge(monthlyall_df_diff_long,how=\"left\",left_on=['Y','lang'],right_on=['Y','lang'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_year_since(row):\n",
    "    if row['lang'] == \"Japanese\":\n",
    "        return row['Y'] - 2003\n",
    "    elif row['lang'] == \"Spanish\":\n",
    "        return row['Y'] - 2002\n",
    "    else:\n",
    "        return row['Y'] - 2001\n",
    "\n",
    "monthlyall_df_long['Y'] = monthlyall_df_long.apply(get_year_since,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1170x827 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## actually making Figure 4\n",
    "\n",
    "fig, ax1 = plt.subplots() # initializes figure and plots\n",
    "\n",
    "ax2 = ax1.twinx() # applies twinx to ax2, which is the second y axis. \n",
    "\n",
    "d = (5,5)\n",
    "dd = [d,d,d,d,d]\n",
    "\n",
    "sb.lineplot(x='Y',y='median_avglag',data=monthlyall_df_long,ax = ax1, color = 'black', style='lang', dashes=dd)\n",
    "sb.lineplot(x='Y',y='median_avglag',data=monthlyall_df_long,ax = ax1, color = 'black', linewidth = 6,ci=None, estimator=np.median)\n",
    "\n",
    "sb.lineplot(x='Y',y='median_avgdiff',data=monthlyall_df_long,ax = ax2, color = 'red', style='lang', dashes=dd)\n",
    "sb.lineplot(x='Y',y='median_avgdiff',data=monthlyall_df_long,ax = ax2, color = 'red', linewidth = 6,ci=None, estimator=np.median)\n",
    "\n",
    "# these lines add the annotations for the plot. \n",
    "\n",
    "ax1.set_ylabel('Diff size in bytes', color='red',fontsize=30)\n",
    "ax1.get_legend().remove()\n",
    "ax1.set_xlabel('')\n",
    "\n",
    "ax2.set_xlim((0,17))\n",
    "ax2.set_xlabel('')\n",
    "ax2.set_ylabel('Lag in seconds (1e6)', color='black',fontsize=30)\n",
    "ax2.get_legend().remove()\n",
    "#ax2.set_yticklabels(labels=[0,25,50,75,100,125,150,175],fontsize=15)\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RQ2 Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "## creating initial structures to map rules over the years starting from their year of creation\n",
    "creation_year_en_df = pd.DataFrame()\n",
    "creation_year_en_df[['page','creation_year']] = rev_df_en[['page','creation_year']]\n",
    "creation_year_en_df.drop_duplicates(inplace=True)\n",
    "\n",
    "creation_year_es_df = pd.DataFrame()\n",
    "creation_year_es_df[['page','creation_year']] = rev_df_es[['page','creation_year']]\n",
    "creation_year_es_df.drop_duplicates(inplace=True)\n",
    "\n",
    "creation_year_fr_df = pd.DataFrame()\n",
    "creation_year_fr_df[['page','creation_year']] = rev_df_fr[['page','creation_year']]\n",
    "creation_year_fr_df.drop_duplicates(inplace=True)\n",
    "\n",
    "creation_year_de_df = pd.DataFrame()\n",
    "creation_year_de_df[['page','creation_year']] = rev_df_de[['page','creation_year']]\n",
    "creation_year_de_df.drop_duplicates(inplace=True)\n",
    "\n",
    "creation_year_ja_df = pd.DataFrame()\n",
    "creation_year_ja_df[['page','creation_year']] = rev_df_ja[['page','creation_year']]\n",
    "creation_year_ja_df.drop_duplicates(inplace=True)\n",
    "\n",
    "creation_year_dfs = [creation_year_en_df,creation_year_fr_df,creation_year_de_df,creation_year_ja_df,creation_year_es_df]\n",
    "all_creation_year_df = pd.concat(creation_year_dfs)\n",
    "langs = ['en', 'fr', 'de', 'ja', 'es']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We originally ran this block of code to get the number of ILLs for each rule per year and exported the files for ease and time. The files are loaded in the next block.\n",
    "```\n",
    "def get_num_ills(row):\n",
    "    #for each page\n",
    "    num_ills_that_year = 0\n",
    "    p = row['parent_page_title']\n",
    "    y = row['year']\n",
    "    #for each ILL\n",
    "    for lang in langs:\n",
    "        # get the interlanguage link\n",
    "        illdpage = all_creation_year_df.loc[all_creation_year_df.page==p][lang].values[0]\n",
    "\n",
    "        #if there is an ILL and it's in our existing rule set\n",
    "        if illdpage != \"\" and illdpage in all_creation_year_df.page.values.tolist(): \n",
    "            # we can check the creation year of that page\n",
    "            illdpage_cyear = all_creation_year_df.loc[all_creation_year_df.page==illdpage]['creation_year'].values[0]\n",
    "            # if that year is before/same as our current year y we can include +1 to the num of ills this page had this year\n",
    "            if int(illdpage_cyear) <= int(y):\n",
    "                num_ills_that_year += 1\n",
    "            # else we cannot, so continue\n",
    "            else:\n",
    "                continue\n",
    "        # there is an ILL but it's not in our existing rule set\n",
    "        elif illdpage != \"\":\n",
    "            # we can get the revision history and grab the date\n",
    "            illdpage_firstyear = pd.concat(wf.get_all_page_revisions(illdpage, endpoint='{}.wikipedia.org/w/api.php'.format(lang))).agg({'date':np.min})['date'].year\n",
    "            if int(illdpage_firstyear) <= int(y):\n",
    "                num_ills_that_year += 1\n",
    "        # there is no link\n",
    "        else:\n",
    "            continue \n",
    "    return num_ills_that_year\n",
    "\n",
    "for i,(rev_df,name) in enumerate(zip(allrev_df_list,rev_df_names)):\n",
    "    print(name)\n",
    "    # map the page to the num of ills that year\n",
    "    _df = rev_df.groupby(['creation_year','parent_page_title','year']).agg({'revid':\"count\"})['revid'].reset_index()\n",
    "    _df['num_ills_that_year'] = _df.apply(get_num_ills,axis=1)\n",
    "    _df.to_csv('202104_num_ills_perpage_peryear_{}.tsv'.format(name),sep='\\t',index=False,header=True)\n",
    "\n",
    "all_creation_year_df.to_csv('202104_rules_withillcolumns',sep='\\t',index=False,header=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_ills_that_year_df_list = [pd.read_csv('202104_num_ills_perpage_peryear_English.tsv',sep='\\t'),\n",
    "                              pd.read_csv('202104_num_ills_perpage_peryear_French.tsv',sep='\\t'),\n",
    "                              pd.read_csv('202104_num_ills_perpage_peryear_German.tsv',sep='\\t'),\n",
    "                              pd.read_csv('202104_num_ills_perpage_peryear_Japanese.tsv',sep='\\t'),\n",
    "                              pd.read_csv('202104_num_ills_perpage_peryear_Spanish.tsv',sep='\\t')]\n",
    "\n",
    "rule_ills = pd.read_csv('202104_rules_withillcolumns',sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We cross check `rule_ills` with the dataframes of the rule revision histories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get ILLs\n",
    "ills = {}\n",
    "\n",
    "rules_df_de = rules_df_de.rename(columns={0: \"NA\", 1: \"links\",2:\"titles\"})\n",
    "rules_df_en = rules_df_en.rename(columns={0: \"NA\", 1: \"links\", 2: \"titles\", 3:\"shortcuts\"})\n",
    "rules_df_es = rules_df_es.rename(columns={0: \"NA\", 1: \"links\", 2: \"titles\", 3:\"shortcuts\"})\n",
    "rules_df_fr = rules_df_fr.rename(columns={0: \"NA\", 1: \"links\", 2: \"titles\", 3:\"shortcuts\"})\n",
    "rules_df_ja = rules_df_ja.rename(columns={0: \"NA\", 1: \"links\", 2: \"titles\", 3:\"shortcuts\"})\n",
    "\n",
    "rules_dfs = [rules_df_de,rules_df_en,rules_df_es,rules_df_fr,rules_df_ja]\n",
    "rules_dfs_dict = {'de':rules_df_de,'en':rules_df_en,'es':rules_df_es,'fr':rules_df_fr,'ja':rules_df_ja}\n",
    "\n",
    "for l in langs:\n",
    "    rules_dfs_dict[l]['lang'] = l\n",
    "\n",
    "rules_to_langs = pd.concat([rules_dfs_dict['de'].drop(columns=['NA','links']),\n",
    "                            rules_dfs_dict['en'].drop(columns=['NA','links','shortcuts']),\n",
    "                            rules_dfs_dict['es'].drop(columns=['NA','links','shortcuts']),\n",
    "                            rules_dfs_dict['fr'].drop(columns=['NA','links','shortcuts']),\n",
    "                            rules_dfs_dict['ja'].drop(columns=['NA','links','shortcuts'])])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Originally, we did the following.\n",
    "First, we built dictionaries of rules and their interlanguage links.\n",
    "```\n",
    "rule_interlanguagelinks_names = dict()\n",
    "rule_interlanguagelinks = dict()\n",
    "\n",
    "def get_ills_aslist_fullname(langlinks_dict):\n",
    "    '''\n",
    "    Takes in the langlinks dict and returns a dictionary that has page titles as keys and a list of ILL language codes + page name as values.\n",
    "    '''\n",
    "    ill_list = dict()\n",
    "    for pagekey in langlinks_dict.keys():\n",
    "        _temp = list()\n",
    "        for langkey in langlinks_dict[pagekey]:\n",
    "            if langkey in langs: #filter for the langs. if we want to get all, just remove this line and unindent following line\n",
    "                _temp.append(\"{}:{}\".format(langkey,langlinks_dict[pagekey][langkey]))\n",
    "        ill_list[pagekey] = _temp\n",
    "    return ill_list\n",
    "\n",
    "def get_ills_aslist(langlinks_dict):\n",
    "    '''\n",
    "    Takes in the langlinks dict and returns a dictionary that has page titles as keys and a list of ILL language codes as values.\n",
    "    '''\n",
    "    ill_list = dict()\n",
    "    for pagekey in langlinks_dict.keys():\n",
    "        _temp = list()\n",
    "        for langkey in langlinks_dict[pagekey]:\n",
    "            if langkey in langs: #filter for the langs. if we want to get all, just remove this line and unindent following line\n",
    "                _temp.append(langkey)\n",
    "        ill_list[pagekey] = _temp\n",
    "    return ill_list\n",
    "\n",
    "for lang in langs:\n",
    "    rule_interlanguagelinks[lang] = get_ills_aslist(ills[lang])\n",
    "    rule_interlanguagelinks_names[lang] = get_ills_aslist_fullname(ills[lang])\n",
    "```\n",
    "Then, we got some metadata about rules with 4 ILLs and 0 ILLs\n",
    "```\n",
    "## all 4 ILLs and 0 ILLs\n",
    "all_ills = []\n",
    "no_ills = []\n",
    "\n",
    "for lang in langs:\n",
    "    for rule in rule_interlanguagelinks[lang]:\n",
    "        if set(['en','es','de','fr','ja']) == set(rule_interlanguagelinks[lang][rule]):\n",
    "            all_ills.append([lang,rule])\n",
    "        elif len(rule_interlanguagelinks[lang][rule]) == 1:\n",
    "            no_ills.append([lang,rule])\n",
    "\n",
    "print(len(all_ills), len(no_ills))\n",
    "\n",
    "# number of revisions\n",
    "def get_num_revisions(row):\n",
    "    lang = row[\"0\"]\n",
    "    page = row[\"1\"]\n",
    "    revs = pd.concat(wf.get_all_page_revisions(page, endpoint='{}.wikipedia.org/w/api.php'.format(lang)))\n",
    "    return len(revs)\n",
    "\n",
    "# number of unique contributors\n",
    "def get_num_ucs(row):\n",
    "    lang = row[\"0\"]\n",
    "    page = row[\"1\"]\n",
    "    revs = pd.concat(wf.get_all_page_revisions(page, endpoint='{}.wikipedia.org/w/api.php'.format(lang)))\n",
    "    revs = revs.groupby(['user']).agg({\"revid\":\"count\"}).reset_index()\n",
    "    return len(revs)\n",
    "\n",
    "all_ills['number_revisions'] = all_ills.apply(get_num_revisions,axis=1)\n",
    "all_ills['number_unique_users'] = all_ills.apply(get_num_ucs,axis=1)\n",
    "none_ills['number_revisions'] = none_ills.apply(get_num_revisions,axis=1)\n",
    "none_ills['number_unique_users'] = none_ills.apply(get_num_ucs,axis=1)\n",
    "```\n",
    "\n",
    "We then exported `all_ills` and `none_ills` as tsvs, and an undergraduate RA checked and added more meta. We then imported that file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_and_none = pd.read_excel(\"ills_all_and_none_reformatted.xlsx\",engine='openpyxl')\n",
    "all_and_none = all_and_none.merge(rule_ills[['page','creation_year']],how=\"left\",left_on=\"Rule Name\",right_on=\"page\")\n",
    "all_ills = all_and_none.loc[all_and_none[\"ILLs in Set\"] == 4]\n",
    "none_ills = all_and_none.loc[all_and_none[\"ILLs in Set\"] == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wikipedia:WikiProject Trinidad and Tobago/Style guide\n"
     ]
    }
   ],
   "source": [
    "for p in none_ills[\"Rule Name\"].values.tolist():\n",
    "    if p not in rule_ills.loc[rule_ills.num_links == 1].page.values.tolist():\n",
    "        print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We checked that the data that was manually updated/checked by the URA is consistent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "## corrections we made by doing manual checking inconsistencies\n",
    "rule_ills.loc[rule_ills.page == \"Wikipedia:No disclaimers in articles\", 'num_links'] = 2\n",
    "rule_ills.loc[rule_ills.page == \"Wikipedia:No disclaimers in articles\", 'en'] = \"Wikipedia:No disclaimers in articles\"\n",
    "rule_ills.loc[rule_ills.page == \"Wikipedia:No disclaimers in articles\", \"ja\"] = \"Wikipedia:記事に免責事項を載せない\"\n",
    "\n",
    "rule_ills.loc[rule_ills.page == \"Wikipedia:Trinidad and Tobago Wikipedians' notice board/Style guide\", 'num_links'] = 1\n",
    "rule_ills.loc[rule_ills.page == \"Wikipedia:Trinidad and Tobago Wikipedians' notice board/Style guide\", 'en'] = \"Wikipedia:Trinidad and Tobago Wikipedians' notice board/Style guide\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wikipedia:Anarchism referencing guidelines\n",
      "Wikipedia:Naming conventions (long lists)\n",
      "Wikipedia:Manual of Style/Anime- and manga-related articles\n",
      "Wikipedia:Manual of Style/Philippine-related articles\n",
      "Aide:Contributions rémunérées\n",
      "Wikipédia:Jouer avec les principes, règles et recommandations de Wikipédia\n",
      "Wikipédia:Supposer la bonne foi\n",
      "Wikipédia:Toujours commenter vos modifications dans la boîte de résumé\n",
      "Aide:Travailler collectivement\n",
      "Wikipédia:Usage raisonné des sources de presse\n",
      "Wikipedia:オープンプロクシは使わない\n",
      "Wikipedia:自分自身の記事をつくらない\n",
      "Wikipedia:外部リンクの選び方\n"
     ]
    }
   ],
   "source": [
    "for x in rules_to_langs.titles.values.tolist():\n",
    "    if x not in rule_ills.page.values.tolist():\n",
    "        print(x)\n",
    "        # these are the pages we're missing in 202104_rules_withillcolumns.\n",
    "        # after checking, we see it is because the difference is the name has changed so we want to update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "## corrections made accordingly\n",
    "ill_name_update = {\"Wikipedia:Anarchism referencing guidelines\":\"Wikipedia:WikiProject Anarchism\",\"Wikipedia:Naming conventions (long lists)\":\"Wikipedia:Naming conventions (lists)\",\n",
    "                    \"Wikipedia:Manual of Style/Anime- and manga-related articles\":\"Wikipedia:Manual of Style/Anime and manga\",\n",
    "                    \"Wikipedia:Manual of Style/Philippine-related articles\":\"Wikipedia:Manual of Style/Philippines-related articles\",\n",
    "                    \"Aide:Contributions rémunérées\":\"Wikipédia:Contributions rémunérées\",\"Wikipédia:Jouer avec les principes, règles et recommandations de Wikipédia\":\"Wikipédia:Ne jouez pas avec les règles\",\n",
    "                    \"Wikipédia:Supposer la bonne foi\":\"Wikipédia:Supposez la bonne foi\",\"Wikipédia:Toujours commenter vos modifications dans la boîte de résumé\":\"Wikipédia:Commentez vos modifications\",\n",
    "                    \"Aide:Travailler collectivement\":\"Wikipédia:Travailler collectivement\",\"Wikipédia:Usage raisonné des sources de presse\":\"Wikipédia:Sources de presse\",\n",
    "                    \"Wikipedia:オープンプロクシは使わない\":\"Wikipedia:公開プロキシの規制\",\"Wikipedia:自分自身の記事をつくらない\":\"Wikipedia:自分自身の記事\",\"Wikipedia:外部リンクの選び方\":\"Wikipedia:外部リンク\"}\n",
    "\n",
    "ill_name_update_reverse = {v: k for k, v in ill_name_update.items()}\n",
    "\n",
    "def update_name(row):\n",
    "    name = row['titles']\n",
    "    if name in list(ill_name_update.keys()):\n",
    "        name = ill_name_update[name]\n",
    "    return name\n",
    "\n",
    "rules_to_langs['titles'] = rules_to_langs.apply(update_name,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "780 780\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>titles</th>\n",
       "      <th>lang</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>Wikipedia:Spam</td>\n",
       "      <td>en</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58</th>\n",
       "      <td>Wikipedia:Spam</td>\n",
       "      <td>es</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            titles lang\n",
       "99  Wikipedia:Spam   en\n",
       "58  Wikipedia:Spam   es"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# quick check that corrections worked\n",
    "for x in rule_ills.page.values.tolist():\n",
    "    if x not in rules_to_langs.titles.values.tolist():\n",
    "        print(x)\n",
    "\n",
    "print(len(rules_to_langs.titles.values.tolist()), len(rule_ills.page.values.tolist()))\n",
    "rules_to_langs.loc[rules_to_langs.titles==\"Wikipedia:Spam\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "rules_to_langs_dict = pd.Series(rules_to_langs.lang.values,index=rules_to_langs.titles).to_dict()\n",
    "\n",
    "def find_lang(row):\n",
    "    if row['page'] == \"Wikipedia:Spam\":\n",
    "        if row['creation_year'] == 2003 or row['creation_year'] == '2003':\n",
    "            return 'en'\n",
    "        else:\n",
    "            return 'es'\n",
    "    return rules_to_langs_dict[row['page']]\n",
    "\n",
    "rule_ills['lang'] = rule_ills.apply(find_lang,axis=1)\n",
    "\n",
    "def get_ills_aslist_fullname_fromdf(row):\n",
    "    out = []\n",
    "    _langs = ['de', 'en', 'es', 'fr', 'ja']\n",
    "    for _l in _langs:\n",
    "        if not pd.isna(row[_l]):\n",
    "            stringed = \"{}:{}\".format(_l,row[_l])\n",
    "            out.append(stringed)\n",
    "    return out\n",
    "\n",
    "def get_ills_aslist_fromdf(row):\n",
    "    _langs = ['de', 'en', 'es', 'fr', 'ja']\n",
    "    out = []\n",
    "    for _l in _langs:\n",
    "        if not pd.isna(row[_l]):\n",
    "            out.append(_l)\n",
    "    return out\n",
    "\n",
    "rule_ills['link_list_name'] = rule_ills.apply(get_ills_aslist_fullname_fromdf,axis=1)\n",
    "rule_ills['link_list'] = rule_ills.apply(get_ills_aslist_fromdf,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "en\n",
      "fr\n",
      "de\n",
      "ja\n",
      "es\n"
     ]
    }
   ],
   "source": [
    "rule_interlanguagelinks_names = dict()\n",
    "rule_interlanguagelinks = dict()\n",
    "\n",
    "for _lang in langs:\n",
    "    print(_lang)\n",
    "    _temp = rule_ills.loc[rule_ills.lang == _lang]\n",
    "    rule_interlanguagelinks[_lang] = pd.Series(_temp.link_list.values,index=_temp.page).to_dict()\n",
    "    rule_interlanguagelinks_names[_lang] = pd.Series(_temp.link_list_name.values,index=_temp.page).to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "en 313\n",
      "fr 127\n",
      "de 122\n",
      "ja 113\n",
      "es 105\n"
     ]
    }
   ],
   "source": [
    "venn_dict = {\"English\":set(),\"French\":set(),\"German\":set(),\"Japanese\":set(),\"Spanish\":set()}\n",
    "shortcut_dict = {\"en\":\"English\",\"de\":\"German\",\"es\":\"Spanish\",\"fr\":\"French\",\"ja\":\"Japanese\"}\n",
    "\n",
    "for lang in langs:\n",
    "    print(lang, len(rule_interlanguagelinks[lang]))\n",
    "    for r in rule_interlanguagelinks[lang]:\n",
    "        links = rule_interlanguagelinks[lang][r]\n",
    "        links_long = [shortcut_dict[l] for l in links]\n",
    "        for l in links_long:\n",
    "            if l not in venn_dict:\n",
    "                venn_dict[l] = set()\n",
    "            venn_dict[l].add(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!{sys.executable} -m pip install venn\n",
    "from venn import venn\n",
    "venn(venn_dict,cmap=sb.color_palette('colorblind',n_colors=5),fmt=\"{percentage:.1f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the figure generated is not very pretty, we redrew this in Adobe Illustrator. That is what we put in the manuscript."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "rule_ills.loc[rule_ills.page == \"Wikipedia:Trinidad and Tobago Wikipedians' notice board/Style guide\", \"page\"] = \"Wikipedia:WikiProject Trinidad and Tobago/Style guide\"\n",
    "## from manual corrections, we know this is a redirect. correcting here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in none_ills[\"Rule Name\"].values.tolist():\n",
    "    if p not in rule_ills.loc[rule_ills.num_links == 1].page.values.tolist():\n",
    "        print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(221, 259)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(all_ills), len(none_ills)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simple descriptive statistics / comparing all ILLs and no ILLs\n",
      "\n",
      "         MEAN REVISIONS       MEDIAN REVISIONS    MEAN CONTRIBUTORS       MED. CONTRIBUTORS       \n",
      "0 ILLs:  176.06177606177607   85.0                69.85328185328186       35.0\n",
      "4 ILLs:  924.0316742081448    328.0               367.81900452488685      161.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# descriptive statistics\n",
    "print(\"\"\"Simple descriptive statistics / comparing all ILLs and no ILLs\n",
    "\n",
    "         MEAN REVISIONS       MEDIAN REVISIONS    MEAN CONTRIBUTORS       MED. CONTRIBUTORS       \n",
    "0 ILLs:  {}   {}                {}       {}\n",
    "4 ILLs:  {}    {}               {}      {}\n",
    "\"\"\".format(none_ills[\"number_revisions\"].mean(),none_ills[\"number_revisions\"].median(),\n",
    "           none_ills[\"number_unique_users\"].mean(),none_ills[\"number_unique_users\"].median(),\n",
    "           all_ills[\"number_revisions\"].mean(),all_ills[\"number_revisions\"].median(),\n",
    "           all_ills[\"number_unique_users\"].mean(),all_ills[\"number_unique_users\"].median() ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5.2483377986822255, 3.8588235294117648, 5.265593752594832, 4.6)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "924.0316742081448/176.06177606177607, 328.0/85.0, 367.81900452488685/69.85328185328186, 161.0/35.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rules with 4 ILLs have 3.86X more revisions and 4.6X more unique contributors than those with no ILLs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>creation_year</th>\n",
       "      <th>rc</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num_links</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2007.617761</td>\n",
       "      <td>344.240310</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2006.810000</td>\n",
       "      <td>246.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2006.629213</td>\n",
       "      <td>224.168539</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2006.495495</td>\n",
       "      <td>233.387387</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2004.452489</td>\n",
       "      <td>113.425339</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           creation_year          rc\n",
       "num_links                           \n",
       "1            2007.617761  344.240310\n",
       "2            2006.810000  246.000000\n",
       "3            2006.629213  224.168539\n",
       "4            2006.495495  233.387387\n",
       "5            2004.452489  113.425339"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rule_ills.groupby(['num_links']).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_creation_year_grouped_df = rule_ills.groupby(by=['creation_year','num_links']).agg({\"page\":\"count\"}).reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_num_rules_with_num_ills_yearly(row):\n",
    "    year =  row['year']\n",
    "    num_links_sofar = all_creation_year_grouped_df.loc[all_creation_year_grouped_df.creation_year <= year].groupby(by=['num_links']).agg({\"page\":\"sum\"}).reset_index()\n",
    "    _out = [year]\n",
    "    for i in range(1,6):\n",
    "        if i in num_links_sofar['num_links'].values.tolist():\n",
    "            so_far = num_links_sofar.loc[num_links_sofar.num_links==i]['page'].values[0]\n",
    "            _out.append(so_far)\n",
    "        else:\n",
    "            _out.append(0)\n",
    "    return _out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "yearly_illcounts_rules = pd.DataFrame()\n",
    "yearly_illcounts_rules['year'] = range(2001,2021)\n",
    "yearly_illcounts_rules = pd.DataFrame(yearly_illcounts_rules.apply(get_num_rules_with_num_ills_yearly,axis=1).tolist(),columns=['year','1','2','3','4','5'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1170x827 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x= yearly_illcounts_rules['year'].values.tolist()\n",
    "y=[ yearly_illcounts_rules['1'].values.tolist(), yearly_illcounts_rules['2'].values.tolist(), yearly_illcounts_rules['3'].values.tolist(), yearly_illcounts_rules['4'].values.tolist(), yearly_illcounts_rules['5'].values.tolist() ]\n",
    " \n",
    "# Plot\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.stackplot(x,y, labels=['0 ILLs','1 ILL','2 ILLs','3 ILLs','4 ILLs'],colors=sb.color_palette('ch:s=.5,hue=0',n_colors=5))\n",
    "plt.xticks(ticks=[2001,2005,2010,2015,2020],labels=[2001,'',2010,'',2020],fontsize=30)\n",
    "plt.yticks(ticks=[0,200,400,600,800],labels=['',200,400,600,800],fontsize=30)\n",
    "plt.xlim(2001,2020)\n",
    "\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(reversed(handles), reversed(labels), loc='upper left',fontsize=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to facet this by language edition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_num_rules_with_num_ills_yearly_perlangedition(row):\n",
    "    year =  row['year']\n",
    "    num_links_sofar = cy_df.loc[cy_df.creation_year <= year].groupby(by=['num_links']).agg({\"page\":\"sum\"}).reset_index()\n",
    "    _out = [year]\n",
    "    for i in range(1,6):\n",
    "        if i in num_links_sofar['num_links'].values.tolist():\n",
    "            so_far = num_links_sofar.loc[num_links_sofar.num_links==i]['page'].values[0]\n",
    "            _out.append(so_far)\n",
    "        else:\n",
    "            _out.append(0)\n",
    "    return _out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "_temp = rule_ills[['page','creation_year','num_links']].copy()\n",
    "\n",
    "_merged_creation_year_dfs = []\n",
    "\n",
    "for _df in creation_year_dfs:\n",
    "    _df = _df.merge(_temp,how=\"left\",left_on=['page','creation_year'],right_on=['page','creation_year'])\n",
    "    _merged_creation_year_dfs.append(_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>page</th>\n",
       "      <th>creation_year</th>\n",
       "      <th>num_links</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Template:Taxobox/doc</td>\n",
       "      <td>2006</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Wikipedia:Accuracy dispute</td>\n",
       "      <td>2003</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Wikipedia:Administrators</td>\n",
       "      <td>2001</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Wikipedia:WikiProject Anarchism</td>\n",
       "      <td>2007</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Wikipedia:Appealing a block</td>\n",
       "      <td>2006</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>308</th>\n",
       "      <td>Wikipedia:WikiProject Mining/Style guide</td>\n",
       "      <td>2009</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>309</th>\n",
       "      <td>Wikipedia:WikiProject Swiss municipalities/Art...</td>\n",
       "      <td>2009</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>310</th>\n",
       "      <td>Wikipedia:Wikimedia sister projects</td>\n",
       "      <td>2004</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>311</th>\n",
       "      <td>Wikipedia:Wikipedia is not a dictionary</td>\n",
       "      <td>2001</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>312</th>\n",
       "      <td>Wikipedia:Wikipedia is not for things made up ...</td>\n",
       "      <td>2005</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>313 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                  page  creation_year  \\\n",
       "0                                 Template:Taxobox/doc           2006   \n",
       "1                           Wikipedia:Accuracy dispute           2003   \n",
       "2                             Wikipedia:Administrators           2001   \n",
       "3                      Wikipedia:WikiProject Anarchism           2007   \n",
       "4                          Wikipedia:Appealing a block           2006   \n",
       "..                                                 ...            ...   \n",
       "308           Wikipedia:WikiProject Mining/Style guide           2009   \n",
       "309  Wikipedia:WikiProject Swiss municipalities/Art...           2009   \n",
       "310                Wikipedia:Wikimedia sister projects           2004   \n",
       "311            Wikipedia:Wikipedia is not a dictionary           2001   \n",
       "312  Wikipedia:Wikipedia is not for things made up ...           2005   \n",
       "\n",
       "     num_links  \n",
       "0          1.0  \n",
       "1          3.0  \n",
       "2          5.0  \n",
       "3          3.0  \n",
       "4          3.0  \n",
       "..         ...  \n",
       "308        1.0  \n",
       "309        1.0  \n",
       "310        3.0  \n",
       "311        5.0  \n",
       "312        1.0  \n",
       "\n",
       "[313 rows x 3 columns]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_merged_creation_year_dfs[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2001, 2001, 2001, 2003, 2002)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rev_df_en.year.astype(np.int64).min(),rev_df_fr.year.astype(np.int64).min(),rev_df_de.year.astype(np.int64).min(),rev_df_ja.year.astype(np.int64).min(),rev_df_es.year.astype(np.int64).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English\n",
      "French\n",
      "German\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\2434208681.py:45: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\2434208681.py:45: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\2434208681.py:45: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Japanese\n",
      "Spanish\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\2434208681.py:45: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f,axs = plt.subplots(1,5,figsize=(24,4))\n",
    "\n",
    "for i,(cy_df,name) in enumerate(zip(_merged_creation_year_dfs,rev_df_names)):\n",
    "    print(name)\n",
    "    # map the page to the num of ills that year\n",
    "    cy_df = cy_df.groupby(by=['creation_year','num_links']).agg({\"page\":\"count\"}).reset_index()\n",
    "    _df = pd.DataFrame()\n",
    "    _df['year'] = range(2001,2021)\n",
    "    _df = pd.DataFrame(_df.apply(get_num_rules_with_num_ills_yearly_perlangedition,axis=1).tolist(),columns=['year','1','2','3','4','5'])\n",
    "\n",
    "    ### For percentages instead\n",
    "    _df['total_rules_num'] = _df['1'] + _df['2'] + _df['3'] + _df['4'] + _df['5']\n",
    "\n",
    "    for number in ['1','2','3','4','5']:\n",
    "        _df[number] = _df[number].astype(np.float32) / _df.total_rules_num.astype(np.float32)\n",
    "    _df.drop(columns=['total_rules_num'],inplace=True)\n",
    "    ### -------------------/\n",
    "    _df.plot(x='year',kind='area',stacked=True,legend=False,ax=axs[i],color=sb.color_palette('ch:s=.5,hue=0',n_colors=5))\n",
    "\n",
    "    if name == \"Japanese\":\n",
    "        axs[i].set_xticks(range(2003,2021))\n",
    "        axs[i].set_xlim(2003,2021)\n",
    "    elif name == \"Spanish\":\n",
    "        axs[i].set_xticks(range(2002,2020))\n",
    "        axs[i].set_xlim(2002,2020)\n",
    "    else:\n",
    "        axs[i].set_xticks(range(2001,2019))\n",
    "        axs[i].set_xlim(2001,2019)\n",
    "    axs[i].set_xticklabels(range(0,18))\n",
    "    axs[i].set_title(name,fontsize=13)\n",
    "    axs[i].set_xlabel('')\n",
    "    axs[i].set_ylim(0,1)\n",
    "\n",
    "    if i == 0:\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "        # uncomment if doing percentages\n",
    "        axs[i].set_yticks([0.0,0.2,0.4,0.6,0.8,1.0])\n",
    "        axs[i].set_yticklabels([0.0,0.2,0.4,0.6,0.8,1.0],fontsize=30)\n",
    "    else:\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "\n",
    "        # uncomment if doing percentages\n",
    "        axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
    "\n",
    "legend_elements = [Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[4], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[3], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[2], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[1], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[0], lw=10)]\n",
    "\n",
    "reversed_labels = [\"4 ILLs\",\"3 ILLs\",\"2 ILLs\",\"1 ILLs\",\"0 ILLs\"]\n",
    "\n",
    "f.legend(legend_elements,reversed_labels,bbox_to_anchor=(1,.9),loc='upper left',fontsize=30)\n",
    "f.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_total_revs_that_year(row):\n",
    "    y = row.year\n",
    "    #print(total_revs_in_year)\n",
    "    return total_revs_in_year['revid'][y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English\n",
      "French\n",
      "German\n",
      "Japanese\n",
      "Spanish\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1675005827.py:48: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1675005827.py:48: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1675005827.py:48: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
      "C:\\Users\\sohye\\AppData\\Local\\Temp\\ipykernel_16496\\1675005827.py:48: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Percent of rule-related revisions going to rules with 0,1,2,3,4 ILLs across lang editions.\n",
    "f,axs = plt.subplots(1,5,figsize=(24,4))\n",
    "\n",
    "for i,(yearlyillcount_rev_df,name) in enumerate(zip(num_ills_that_year_df_list,rev_df_names)):\n",
    "    print(name)\n",
    "    # map the page to the num of ills that year\n",
    "    _df = yearlyillcount_rev_df.groupby(['year','num_ills_that_year']).agg({'revid':'sum'}).reset_index()\n",
    "    _df['lang'] = name\n",
    "\n",
    "    total_revs_in_year = _df.groupby(['year']).agg({'revid':sum}).to_dict()\n",
    "    _df['total_revs_yearly'] = _df.apply(get_total_revs_that_year,axis=1)\n",
    "\n",
    "    _df[\"percentage_revs\"] = _df.revid.astype(np.float32) / _df.total_revs_yearly.astype(np.float32)\n",
    "    _df = _df.groupby([\"lang\",\"year\",\"num_ills_that_year\"]).agg({\"percentage_revs\":\"sum\"}).reset_index()\n",
    "    _df = _df.pivot(index=\"year\",columns=\"num_ills_that_year\",values=\"percentage_revs\").fillna(value=0)\\\n",
    "\n",
    "    if 0 in list(_df.columns):\n",
    "        _df[\"temp_col\"] = _df[0] + _df[1]\n",
    "        _df[1] = _df[\"temp_col\"]\n",
    "        _df = _df.drop(columns=[0,\"temp_col\"])\n",
    "\n",
    "    _df.plot(kind='area',stacked=True,legend=False,ax=axs[i],color=sb.color_palette('ch:s=.5,hue=0',n_colors=5))\n",
    "\n",
    "    if name == \"Japanese\":\n",
    "        axs[i].set_xticks(range(2003,2021))\n",
    "        axs[i].set_xlim(2003,2021)\n",
    "    elif name == \"Spanish\":\n",
    "        axs[i].set_xticks(range(2002,2020))\n",
    "        axs[i].set_xlim(2002,2020)\n",
    "    else:\n",
    "        axs[i].set_xticks(range(2001,2019))\n",
    "        axs[i].set_xlim(2001,2019)\n",
    "    axs[i].set_xticklabels(range(0,18))\n",
    "    axs[i].set_title(name,fontsize=13)\n",
    "    axs[i].set_xlabel('')\n",
    "    axs[i].set_ylim(0,1)\n",
    "\n",
    "    if i == 0:\n",
    "        #axs[i].set_xticklabels(range(0,20))\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "        axs[i].set_yticks([0.0,0.2,0.4,0.6,0.8,1.0])\n",
    "        axs[i].set_yticklabels([0.0,0.2,0.4,0.6,0.8,1.0],fontsize=30)\n",
    "\n",
    "    else:\n",
    "        axs[i].set_title(name,fontsize=30)\n",
    "        axs[i].set_xlabel('')\n",
    "        axs[i].set_yticklabels([\"\",\"\",\"\",\"\",\"\",\"\"])\n",
    "\n",
    "legend_elements = [Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[4], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[3], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[2], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[1], lw=10),\n",
    "                   Line2D([0], [0], color=sb.color_palette('ch:s=.5,hue=0',n_colors=5)[0], lw=10)]\n",
    "\n",
    "reversed_labels = [\"4 ILLs\",\"3 ILLs\",\"2 ILLs\",\"1 ILLs\",\"0 ILLs\"]\n",
    "\n",
    "f.legend(legend_elements,reversed_labels,bbox_to_anchor=(1,.9),loc='upper left',fontsize=30)\n",
    "f.tight_layout();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "219346b13714f768f9488e9b37d2a769c34fb63960c6dbb9230676da542bbf26"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
